{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# For tips on running notebooks in Google Colab, see\n",
    "# https://pytorch.org/tutorials/beginner/colab\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reinforcement Learning (PPO) with TorchRL Tutorial\n",
    "==================================================\n",
    "\n",
    "**Author**: [Vincent Moens](https://github.com/vmoens)\n",
    "\n",
    "This tutorial demonstrates how to use PyTorch and\n",
    ":py`torchrl`{.interpreted-text role=\"mod\"} to train a parametric policy\n",
    "network to solve the Inverted Pendulum task from the\n",
    "[OpenAI-Gym/Farama-Gymnasium control\n",
    "library](https://github.com/Farama-Foundation/Gymnasium).\n",
    "\n",
    "![Inverted\n",
    "pendulum](https://pytorch.org/tutorials/_static/img/invpendulum.gif)\n",
    "\n",
    "Key learnings:\n",
    "\n",
    "-   How to create an environment in TorchRL, transform its outputs, and\n",
    "    collect data from this environment;\n",
    "-   How to make your classes talk to each other using\n",
    "    `~tensordict.TensorDict`{.interpreted-text role=\"class\"};\n",
    "-   The basics of building your training loop with TorchRL:\n",
    "    -   How to compute the advantage signal for policy gradient methods;\n",
    "    -   How to create a stochastic policy using a probabilistic neural\n",
    "        network;\n",
    "    -   How to create a dynamic replay buffer and sample from it without\n",
    "        repetition.\n",
    "\n",
    "We will cover six crucial components of TorchRL:\n",
    "\n",
    "-   [environments](https://pytorch.org/rl/reference/envs.html)\n",
    "-   [transforms](https://pytorch.org/rl/reference/envs.html#transforms)\n",
    "-   [models (policy and value\n",
    "    function)](https://pytorch.org/rl/reference/modules.html)\n",
    "-   [loss modules](https://pytorch.org/rl/reference/objectives.html)\n",
    "-   [data collectors](https://pytorch.org/rl/reference/collectors.html)\n",
    "-   [replay\n",
    "    buffers](https://pytorch.org/rl/reference/data.html#replay-buffers)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are running this in Google Colab, make sure you install the\n",
    "following dependencies:\n",
    "\n",
    "``` {.bash}\n",
    "!pip3 install torchrl\n",
    "!pip3 install gym[mujoco]\n",
    "!pip3 install tqdm\n",
    "```\n",
    "\n",
    "Proximal Policy Optimization (PPO) is a policy-gradient algorithm where\n",
    "a batch of data is being collected and directly consumed to train the\n",
    "policy to maximise the expected return given some proximality\n",
    "constraints. You can think of it as a sophisticated version of\n",
    "[REINFORCE](https://link.springer.com/content/pdf/10.1007/BF00992696.pdf),\n",
    "the foundational policy-optimization algorithm. For more information,\n",
    "see the [Proximal Policy Optimization\n",
    "Algorithms](https://arxiv.org/abs/1707.06347) paper.\n",
    "\n",
    "PPO is usually regarded as a fast and efficient method for online,\n",
    "on-policy reinforcement algorithm. TorchRL provides a loss-module that\n",
    "does all the work for you, so that you can rely on this implementation\n",
    "and focus on solving your problem rather than re-inventing the wheel\n",
    "every time you want to train a policy.\n",
    "\n",
    "For completeness, here is a brief overview of what the loss computes,\n",
    "even though this is taken care of by our\n",
    "`~torchrl.objectives.ClipPPOLoss`{.interpreted-text role=\"class\"}\n",
    "module---the algorithm works as follows: 1. we will sample a batch of\n",
    "data by playing the policy in the environment for a given number of\n",
    "steps. 2. Then, we will perform a given number of optimization steps\n",
    "with random sub-samples of this batch using a clipped version of the\n",
    "REINFORCE loss. 3. The clipping will put a pessimistic bound on our\n",
    "loss: lower return estimates will be favored compared to higher ones.\n",
    "The precise formula of the loss is:\n",
    "\n",
    "$$L(s,a,\\theta_k,\\theta) = \\min\\left(\n",
    "\\frac{\\pi_{\\theta}(a|s)}{\\pi_{\\theta_k}(a|s)}  A^{\\pi_{\\theta_k}}(s,a), \\;\\;\n",
    "g(\\epsilon, A^{\\pi_{\\theta_k}}(s,a))\n",
    "\\right),$$\n",
    "\n",
    "There are two components in that loss: in the first part of the minimum\n",
    "operator, we simply compute an importance-weighted version of the\n",
    "REINFORCE loss (for example, a REINFORCE loss that we have corrected for\n",
    "the fact that the current policy configuration lags the one that was\n",
    "used for the data collection). The second part of that minimum operator\n",
    "is a similar loss where we have clipped the ratios when they exceeded or\n",
    "were below a given pair of thresholds.\n",
    "\n",
    "This loss ensures that whether the advantage is positive or negative,\n",
    "policy updates that would produce significant shifts from the previous\n",
    "configuration are being discouraged.\n",
    "\n",
    "This tutorial is structured as follows:\n",
    "\n",
    "1.  First, we will define a set of hyperparameters we will be using for\n",
    "    training.\n",
    "2.  Next, we will focus on creating our environment, or simulator, using\n",
    "    TorchRL\\'s wrappers and transforms.\n",
    "3.  Next, we will design the policy network and the value model, which\n",
    "    is indispensable to the loss function. These modules will be used to\n",
    "    configure our loss module.\n",
    "4.  Next, we will create the replay buffer and data loader.\n",
    "5.  Finally, we will run our training loop and analyze the results.\n",
    "\n",
    "Throughout this tutorial, we\\'ll be using the\n",
    "`tensordict`{.interpreted-text role=\"mod\"} library.\n",
    "`~tensordict.TensorDict`{.interpreted-text role=\"class\"} is the lingua\n",
    "franca of TorchRL: it helps us abstract what a module reads and writes\n",
    "and care less about the specific data description and more about the\n",
    "algorithm itself.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "from torch import multiprocessing\n",
    "\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from tensordict.nn import TensorDictModule\n",
    "from tensordict.nn.distributions import NormalParamExtractor\n",
    "from torch import nn\n",
    "from torchrl.collectors import SyncDataCollector\n",
    "from torchrl.data.replay_buffers import ReplayBuffer\n",
    "from torchrl.data.replay_buffers.samplers import SamplerWithoutReplacement\n",
    "from torchrl.data.replay_buffers.storages import LazyTensorStorage\n",
    "from torchrl.envs import (Compose, DoubleToFloat, ObservationNorm, StepCounter,\n",
    "                          TransformedEnv)\n",
    "from torchrl.envs.libs.gym import GymEnv\n",
    "from torchrl.envs.utils import check_env_specs, ExplorationType, set_exploration_type\n",
    "from torchrl.modules import ProbabilisticActor, TanhNormal, ValueOperator\n",
    "from torchrl.objectives import ClipPPOLoss\n",
    "from torchrl.objectives.value import GAE\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define Hyperparameters\n",
    "======================\n",
    "\n",
    "We set the hyperparameters for our algorithm. Depending on the resources\n",
    "available, one may choose to execute the policy on GPU or on another\n",
    "device. The `frame_skip` will control how for how many frames is a\n",
    "single action being executed. The rest of the arguments that count\n",
    "frames must be corrected for this value (since one environment step will\n",
    "actually return `frame_skip` frames).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "is_fork = multiprocessing.get_start_method() == \"fork\"\n",
    "device = (\n",
    "    torch.device(0)\n",
    "    if torch.cuda.is_available() and not is_fork\n",
    "    else torch.device(\"cpu\")\n",
    ")\n",
    "num_cells = 256  # number of cells in each layer i.e. output dim.\n",
    "lr = 3e-4\n",
    "max_grad_norm = 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data collection parameters\n",
    "==========================\n",
    "\n",
    "When collecting data, we will be able to choose how big each batch will\n",
    "be by defining a `frames_per_batch` parameter. We will also define how\n",
    "many frames (such as the number of interactions with the simulator) we\n",
    "will allow ourselves to use. In general, the goal of an RL algorithm is\n",
    "to learn to solve the task as fast as it can in terms of environment\n",
    "interactions: the lower the `total_frames` the better.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "frames_per_batch = 1000\n",
    "# For a complete training, bring the number of frames up to 1M\n",
    "total_frames = 50_000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PPO parameters\n",
    "==============\n",
    "\n",
    "At each data collection (or batch collection) we will run the\n",
    "optimization over a certain number of *epochs*, each time consuming the\n",
    "entire data we just acquired in a nested training loop. Here, the\n",
    "`sub_batch_size` is different from the `frames_per_batch` here above:\n",
    "recall that we are working with a \\\"batch of data\\\" coming from our\n",
    "collector, which size is defined by `frames_per_batch`, and that we will\n",
    "further split in smaller sub-batches during the inner training loop. The\n",
    "size of these sub-batches is controlled by `sub_batch_size`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sub_batch_size = 64  # cardinality of the sub-samples gathered from the current data in the inner loop\n",
    "num_epochs = 10  # optimization steps per batch of data collected\n",
    "clip_epsilon = (\n",
    "    0.2  # clip value for PPO loss: see the equation in the intro for more context.\n",
    ")\n",
    "gamma = 0.99\n",
    "lmbda = 0.95\n",
    "entropy_eps = 1e-4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define an environment\n",
    "=====================\n",
    "\n",
    "In RL, an *environment* is usually the way we refer to a simulator or a\n",
    "control system. Various libraries provide simulation environments for\n",
    "reinforcement learning, including Gymnasium (previously OpenAI Gym),\n",
    "DeepMind control suite, and many others. As a general library,\n",
    "TorchRL\\'s goal is to provide an interchangeable interface to a large\n",
    "panel of RL simulators, allowing you to easily swap one environment with\n",
    "another. For example, creating a wrapped gym environment can be achieved\n",
    "with few characters:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "base_env = GymEnv(\"InvertedDoublePendulum-v4\", device=device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few things to notice in this code: first, we created the\n",
    "environment by calling the `GymEnv` wrapper. If extra keyword arguments\n",
    "are passed, they will be transmitted to the `gym.make` method, hence\n",
    "covering the most common environment construction commands.\n",
    "Alternatively, one could also directly create a gym environment using\n",
    "`gym.make(env_name, **kwargs)` and wrap it in a [GymWrapper]{.title-ref}\n",
    "class.\n",
    "\n",
    "Also the `device` argument: for gym, this only controls the device where\n",
    "input action and observed states will be stored, but the execution will\n",
    "always be done on CPU. The reason for this is simply that gym does not\n",
    "support on-device execution, unless specified otherwise. For other\n",
    "libraries, we have control over the execution device and, as much as we\n",
    "can, we try to stay consistent in terms of storing and execution\n",
    "backends.\n",
    "\n",
    "Transforms\n",
    "==========\n",
    "\n",
    "We will append some transforms to our environments to prepare the data\n",
    "for the policy. In Gym, this is usually achieved via wrappers. TorchRL\n",
    "takes a different approach, more similar to other pytorch domain\n",
    "libraries, through the use of transforms. To add transforms to an\n",
    "environment, one should simply wrap it in a\n",
    "`~torchrl.envs.transforms.TransformedEnv`{.interpreted-text\n",
    "role=\"class\"} instance and append the sequence of transforms to it. The\n",
    "transformed environment will inherit the device and meta-data of the\n",
    "wrapped environment, and transform these depending on the sequence of\n",
    "transforms it contains.\n",
    "\n",
    "Normalization\n",
    "=============\n",
    "\n",
    "The first to encode is a normalization transform. As a rule of thumbs,\n",
    "it is preferable to have data that loosely match a unit Gaussian\n",
    "distribution: to obtain this, we will run a certain number of random\n",
    "steps in the environment and compute the summary statistics of these\n",
    "observations.\n",
    "\n",
    "We\\'ll append two other transforms: the\n",
    "`~torchrl.envs.transforms.DoubleToFloat`{.interpreted-text role=\"class\"}\n",
    "transform will convert double entries to single-precision numbers, ready\n",
    "to be read by the policy. The\n",
    "`~torchrl.envs.transforms.StepCounter`{.interpreted-text role=\"class\"}\n",
    "transform will be used to count the steps before the environment is\n",
    "terminated. We will use this measure as a supplementary measure of\n",
    "performance.\n",
    "\n",
    "As we will see later, many of the TorchRL\\'s classes rely on\n",
    "`~tensordict.TensorDict`{.interpreted-text role=\"class\"} to communicate.\n",
    "You could think of it as a python dictionary with some extra tensor\n",
    "features. In practice, this means that many modules we will be working\n",
    "with need to be told what key to read (`in_keys`) and what key to write\n",
    "(`out_keys`) in the `tensordict` they will receive. Usually, if\n",
    "`out_keys` is omitted, it is assumed that the `in_keys` entries will be\n",
    "updated in-place. For our transforms, the only entry we are interested\n",
    "in is referred to as `\"observation\"` and our transform layers will be\n",
    "told to modify this entry and this entry only:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "env = TransformedEnv(\n",
    "    base_env,\n",
    "    Compose(\n",
    "        # normalize observations\n",
    "        ObservationNorm(in_keys=[\"observation\"]),\n",
    "        DoubleToFloat(),\n",
    "        StepCounter(),\n",
    "    ),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you may have noticed, we have created a normalization layer but we\n",
    "did not set its normalization parameters. To do this,\n",
    "`~torchrl.envs.transforms.ObservationNorm`{.interpreted-text\n",
    "role=\"class\"} can automatically gather the summary statistics of our\n",
    "environment:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "env.transform[0].init_stats(num_iter=1000, reduce_dim=0, cat_dim=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `~torchrl.envs.transforms.ObservationNorm`{.interpreted-text\n",
    "role=\"class\"} transform has now been populated with a location and a\n",
    "scale that will be used to normalize the data.\n",
    "\n",
    "Let us do a little sanity check for the shape of our summary stats:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "normalization constant shape: torch.Size([11])\n"
     ]
    }
   ],
   "source": [
    "print(\"normalization constant shape:\", env.transform[0].loc.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An environment is not only defined by its simulator and transforms, but\n",
    "also by a series of metadata that describe what can be expected during\n",
    "its execution. For efficiency purposes, TorchRL is quite stringent when\n",
    "it comes to environment specs, but you can easily check that your\n",
    "environment specs are adequate. In our example, the\n",
    "`~torchrl.envs.libs.gym.GymWrapper`{.interpreted-text role=\"class\"} and\n",
    "`~torchrl.envs.libs.gym.GymEnv`{.interpreted-text role=\"class\"} that\n",
    "inherits from it already take care of setting the proper specs for your\n",
    "environment so you should not have to care about this.\n",
    "\n",
    "Nevertheless, let\\'s see a concrete example using our transformed\n",
    "environment by looking at its specs. There are three specs to look at:\n",
    "`observation_spec` which defines what is to be expected when executing\n",
    "an action in the environment, `reward_spec` which indicates the reward\n",
    "domain and finally the `input_spec` (which contains the `action_spec`)\n",
    "and which represents everything an environment requires to execute a\n",
    "single step.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "observation_spec: CompositeSpec(\n",
      "    observation: UnboundedContinuousTensorSpec(\n",
      "        shape=torch.Size([11]),\n",
      "        space=None,\n",
      "        device=cpu,\n",
      "        dtype=torch.float32,\n",
      "        domain=continuous),\n",
      "    step_count: BoundedTensorSpec(\n",
      "        shape=torch.Size([1]),\n",
      "        space=ContinuousBox(\n",
      "            low=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.int64, contiguous=True),\n",
      "            high=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.int64, contiguous=True)),\n",
      "        device=cpu,\n",
      "        dtype=torch.int64,\n",
      "        domain=continuous), device=cpu, shape=torch.Size([]))\n",
      "reward_spec: UnboundedContinuousTensorSpec(\n",
      "    shape=torch.Size([1]),\n",
      "    space=ContinuousBox(\n",
      "        low=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, contiguous=True),\n",
      "        high=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, contiguous=True)),\n",
      "    device=cpu,\n",
      "    dtype=torch.float32,\n",
      "    domain=continuous)\n",
      "input_spec: CompositeSpec(\n",
      "    full_state_spec: CompositeSpec(\n",
      "        step_count: BoundedTensorSpec(\n",
      "            shape=torch.Size([1]),\n",
      "            space=ContinuousBox(\n",
      "                low=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.int64, contiguous=True),\n",
      "                high=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.int64, contiguous=True)),\n",
      "            device=cpu,\n",
      "            dtype=torch.int64,\n",
      "            domain=continuous), device=cpu, shape=torch.Size([])),\n",
      "    full_action_spec: CompositeSpec(\n",
      "        action: BoundedTensorSpec(\n",
      "            shape=torch.Size([1]),\n",
      "            space=ContinuousBox(\n",
      "                low=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, contiguous=True),\n",
      "                high=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, contiguous=True)),\n",
      "            device=cpu,\n",
      "            dtype=torch.float32,\n",
      "            domain=continuous), device=cpu, shape=torch.Size([])), device=cpu, shape=torch.Size([]))\n",
      "action_spec (as defined by input_spec): BoundedTensorSpec(\n",
      "    shape=torch.Size([1]),\n",
      "    space=ContinuousBox(\n",
      "        low=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, contiguous=True),\n",
      "        high=Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, contiguous=True)),\n",
      "    device=cpu,\n",
      "    dtype=torch.float32,\n",
      "    domain=continuous)\n"
     ]
    }
   ],
   "source": [
    "print(\"observation_spec:\", env.observation_spec)\n",
    "print(\"reward_spec:\", env.reward_spec)\n",
    "print(\"input_spec:\", env.input_spec)\n",
    "print(\"action_spec (as defined by input_spec):\", env.action_spec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the `check_env_specs`{.interpreted-text role=\"func\"} function runs a\n",
    "small rollout and compares its output against the environment specs. If\n",
    "no error is raised, we can be confident that the specs are properly\n",
    "defined:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-11-17 17:57:37,713 [torchrl][INFO] check_env_specs succeeded!\n"
     ]
    }
   ],
   "source": [
    "check_env_specs(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For fun, let\\'s see what a simple random rollout looks like. You can\n",
    "call [env.rollout(n\\_steps)]{.title-ref} and get an overview of what the\n",
    "environment inputs and outputs look like. Actions will automatically be\n",
    "drawn from the action spec domain, so you don\\'t need to care about\n",
    "designing a random sampler.\n",
    "\n",
    "Typically, at each step, an RL environment receives an action as input,\n",
    "and outputs an observation, a reward and a done state. The observation\n",
    "may be composite, meaning that it could be composed of more than one\n",
    "tensor. This is not a problem for TorchRL, since the whole set of\n",
    "observations is automatically packed in the output\n",
    "`~tensordict.TensorDict`{.interpreted-text role=\"class\"}. After\n",
    "executing a rollout (for example, a sequence of environment steps and\n",
    "random action generations) over a given number of steps, we will\n",
    "retrieve a `~tensordict.TensorDict`{.interpreted-text role=\"class\"}\n",
    "instance with a shape that matches this trajectory length:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rollout of three steps: TensorDict(\n",
      "    fields={\n",
      "        action: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "        done: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False),\n",
      "        next: TensorDict(\n",
      "            fields={\n",
      "                done: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False),\n",
      "                observation: Tensor(shape=torch.Size([3, 11]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "                reward: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "                step_count: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.int64, is_shared=False),\n",
      "                terminated: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False),\n",
      "                truncated: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False)},\n",
      "            batch_size=torch.Size([3]),\n",
      "            device=cpu,\n",
      "            is_shared=False),\n",
      "        observation: Tensor(shape=torch.Size([3, 11]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "        step_count: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.int64, is_shared=False),\n",
      "        terminated: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False),\n",
      "        truncated: Tensor(shape=torch.Size([3, 1]), device=cpu, dtype=torch.bool, is_shared=False)},\n",
      "    batch_size=torch.Size([3]),\n",
      "    device=cpu,\n",
      "    is_shared=False)\n",
      "Shape of the rollout TensorDict: torch.Size([3])\n"
     ]
    }
   ],
   "source": [
    "rollout = env.rollout(3)\n",
    "print(\"rollout of three steps:\", rollout)\n",
    "print(\"Shape of the rollout TensorDict:\", rollout.batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our rollout data has a shape of `torch.Size([3])`, which matches the\n",
    "number of steps we ran it for. The `\"next\"` entry points to the data\n",
    "coming after the current step. In most cases, the `\"next\"` data at time\n",
    "[t]{.title-ref} matches the data at `t+1`, but this may not be the case\n",
    "if we are using some specific transformations (for example, multi-step).\n",
    "\n",
    "Policy\n",
    "======\n",
    "\n",
    "PPO utilizes a stochastic policy to handle exploration. This means that\n",
    "our neural network will have to output the parameters of a distribution,\n",
    "rather than a single value corresponding to the action taken.\n",
    "\n",
    "As the data is continuous, we use a Tanh-Normal distribution to respect\n",
    "the action space boundaries. TorchRL provides such distribution, and the\n",
    "only thing we need to care about is to build a neural network that\n",
    "outputs the right number of parameters for the policy to work with (a\n",
    "location, or mean, and a scale):\n",
    "\n",
    "$$f_{\\theta}(\\text{observation}) = \\mu_{\\theta}(\\text{observation}), \\sigma^{+}_{\\theta}(\\text{observation})$$\n",
    "\n",
    "The only extra-difficulty that is brought up here is to split our output\n",
    "in two equal parts and map the second to a strictly positive space.\n",
    "\n",
    "We design the policy in three steps:\n",
    "\n",
    "1.  Define a neural network `D_obs` -\\> `2 * D_action`. Indeed, our\n",
    "    `loc` (mu) and `scale` (sigma) both have dimension `D_action`.\n",
    "2.  Append a\n",
    "    `~tensordict.nn.distributions.NormalParamExtractor`{.interpreted-text\n",
    "    role=\"class\"} to extract a location and a scale (for example, splits\n",
    "    the input in two equal parts and applies a positive transformation\n",
    "    to the scale parameter).\n",
    "3.  Create a probabilistic\n",
    "    `~tensordict.nn.TensorDictModule`{.interpreted-text role=\"class\"}\n",
    "    that can generate this distribution and sample from it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "actor_net = nn.Sequential(\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.Tanh(),\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.Tanh(),\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.Tanh(),\n",
    "    nn.LazyLinear(2 * env.action_spec.shape[-1], device=device),\n",
    "    NormalParamExtractor(),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To enable the policy to \\\"talk\\\" with the environment through the\n",
    "`tensordict` data carrier, we wrap the `nn.Module` in a\n",
    "`~tensordict.nn.TensorDictModule`{.interpreted-text role=\"class\"}. This\n",
    "class will simply ready the `in_keys` it is provided with and write the\n",
    "outputs in-place at the registered `out_keys`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "policy_module = TensorDictModule(\n",
    "    actor_net, in_keys=[\"observation\"], out_keys=[\"loc\", \"scale\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now need to build a distribution out of the location and scale of our\n",
    "normal distribution. To do so, we instruct the\n",
    "`~torchrl.modules.tensordict_module.ProbabilisticActor`{.interpreted-text\n",
    "role=\"class\"} class to build a\n",
    "`~torchrl.modules.TanhNormal`{.interpreted-text role=\"class\"} out of the\n",
    "location and scale parameters. We also provide the minimum and maximum\n",
    "values of this distribution, which we gather from the environment specs.\n",
    "\n",
    "The name of the `in_keys` (and hence the name of the `out_keys` from the\n",
    "`~tensordict.nn.TensorDictModule`{.interpreted-text role=\"class\"} above)\n",
    "cannot be set to any value one may like, as the\n",
    "`~torchrl.modules.TanhNormal`{.interpreted-text role=\"class\"}\n",
    "distribution constructor will expect the `loc` and `scale` keyword\n",
    "arguments. That being said,\n",
    "`~torchrl.modules.tensordict_module.ProbabilisticActor`{.interpreted-text\n",
    "role=\"class\"} also accepts `Dict[str, str]` typed `in_keys` where the\n",
    "key-value pair indicates what `in_key` string should be used for every\n",
    "keyword argument that is to be used.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "policy_module = ProbabilisticActor(\n",
    "    module=policy_module,\n",
    "    spec=env.action_spec,\n",
    "    in_keys=[\"loc\", \"scale\"],\n",
    "    distribution_class=TanhNormal,\n",
    "    distribution_kwargs={\n",
    "        \"min\": env.action_spec.space.low,\n",
    "        \"max\": env.action_spec.space.high,\n",
    "    },\n",
    "    return_log_prob=True,\n",
    "    # we'll need the log-prob for the numerator of the importance weights\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Value network\n",
    "=============\n",
    "\n",
    "The value network is a crucial component of the PPO algorithm, even\n",
    "though it won\\'t be used at inference time. This module will read the\n",
    "observations and return an estimation of the discounted return for the\n",
    "following trajectory. This allows us to amortize learning by relying on\n",
    "the some utility estimation that is learned on-the-fly during training.\n",
    "Our value network share the same structure as the policy, but for\n",
    "simplicity we assign it its own set of parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "value_net = nn.Sequential(\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.Tanh(),\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.Tanh(),\n",
    "    nn.LazyLinear(num_cells, device=device),\n",
    "    nn.Tanh(),\n",
    "    nn.LazyLinear(1, device=device),\n",
    ")\n",
    "\n",
    "value_module = ValueOperator(\n",
    "    module=value_net,\n",
    "    in_keys=[\"observation\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let\\'s try our policy and value modules. As we said earlier, the usage\n",
    "of `~tensordict.nn.TensorDictModule`{.interpreted-text role=\"class\"}\n",
    "makes it possible to directly read the output of the environment to run\n",
    "these modules, as they know what information to read and where to write\n",
    "it:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running policy: TensorDict(\n",
      "    fields={\n",
      "        action: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "        done: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False),\n",
      "        loc: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "        observation: Tensor(shape=torch.Size([11]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "        sample_log_prob: Tensor(shape=torch.Size([]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "        scale: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "        step_count: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.int64, is_shared=False),\n",
      "        terminated: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False),\n",
      "        truncated: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False)},\n",
      "    batch_size=torch.Size([]),\n",
      "    device=cpu,\n",
      "    is_shared=False)\n",
      "Running value: TensorDict(\n",
      "    fields={\n",
      "        done: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False),\n",
      "        observation: Tensor(shape=torch.Size([11]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "        state_value: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, is_shared=False),\n",
      "        step_count: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.int64, is_shared=False),\n",
      "        terminated: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False),\n",
      "        truncated: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False)},\n",
      "    batch_size=torch.Size([]),\n",
      "    device=cpu,\n",
      "    is_shared=False)\n"
     ]
    }
   ],
   "source": [
    "print(\"Running policy:\", policy_module(env.reset()))\n",
    "print(\"Running value:\", value_module(env.reset()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data collector\n",
    "==============\n",
    "\n",
    "TorchRL provides a set of [DataCollector\n",
    "classes](https://pytorch.org/rl/reference/collectors.html). Briefly,\n",
    "these classes execute three operations: reset an environment, compute an\n",
    "action given the latest observation, execute a step in the environment,\n",
    "and repeat the last two steps until the environment signals a stop (or\n",
    "reaches a done state).\n",
    "\n",
    "They allow you to control how many frames to collect at each iteration\n",
    "(through the `frames_per_batch` parameter), when to reset the\n",
    "environment (through the `max_frames_per_traj` argument), on which\n",
    "`device` the policy should be executed, etc. They are also designed to\n",
    "work efficiently with batched and multiprocessed environments.\n",
    "\n",
    "The simplest data collector is the\n",
    "`~torchrl.collectors.collectors.SyncDataCollector`{.interpreted-text\n",
    "role=\"class\"}: it is an iterator that you can use to get batches of data\n",
    "of a given length, and that will stop once a total number of frames\n",
    "(`total_frames`) have been collected. Other data collectors\n",
    "(`~torchrl.collectors.collectors.MultiSyncDataCollector`{.interpreted-text\n",
    "role=\"class\"} and\n",
    "`~torchrl.collectors.collectors.MultiaSyncDataCollector`{.interpreted-text\n",
    "role=\"class\"}) will execute the same operations in synchronous and\n",
    "asynchronous manner over a set of multiprocessed workers.\n",
    "\n",
    "As for the policy and environment before, the data collector will return\n",
    "`~tensordict.TensorDict`{.interpreted-text role=\"class\"} instances with\n",
    "a total number of elements that will match `frames_per_batch`. Using\n",
    "`~tensordict.TensorDict`{.interpreted-text role=\"class\"} to pass data to\n",
    "the training loop allows you to write data loading pipelines that are\n",
    "100% oblivious to the actual specificities of the rollout content.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "collector = SyncDataCollector(\n",
    "    env,\n",
    "    policy_module,\n",
    "    frames_per_batch=frames_per_batch,\n",
    "    total_frames=total_frames,\n",
    "    split_trajs=False,\n",
    "    device=device,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Replay buffer\n",
    "=============\n",
    "\n",
    "Replay buffers are a common building piece of off-policy RL algorithms.\n",
    "In on-policy contexts, a replay buffer is refilled every time a batch of\n",
    "data is collected, and its data is repeatedly consumed for a certain\n",
    "number of epochs.\n",
    "\n",
    "TorchRL\\'s replay buffers are built using a common container\n",
    "`~torchrl.data.ReplayBuffer`{.interpreted-text role=\"class\"} which takes\n",
    "as argument the components of the buffer: a storage, a writer, a sampler\n",
    "and possibly some transforms. Only the storage (which indicates the\n",
    "replay buffer capacity) is mandatory. We also specify a sampler without\n",
    "repetition to avoid sampling multiple times the same item in one epoch.\n",
    "Using a replay buffer for PPO is not mandatory and we could simply\n",
    "sample the sub-batches from the collected batch, but using these classes\n",
    "make it easy for us to build the inner training loop in a reproducible\n",
    "way.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "replay_buffer = ReplayBuffer(\n",
    "    storage=LazyTensorStorage(max_size=frames_per_batch),\n",
    "    sampler=SamplerWithoutReplacement(),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loss function\n",
    "=============\n",
    "\n",
    "The PPO loss can be directly imported from TorchRL for convenience using\n",
    "the `~torchrl.objectives.ClipPPOLoss`{.interpreted-text role=\"class\"}\n",
    "class. This is the easiest way of utilizing PPO: it hides away the\n",
    "mathematical operations of PPO and the control flow that goes with it.\n",
    "\n",
    "PPO requires some \\\"advantage estimation\\\" to be computed. In short, an\n",
    "advantage is a value that reflects an expectancy over the return value\n",
    "while dealing with the bias / variance tradeoff. To compute the\n",
    "advantage, one just needs to (1) build the advantage module, which\n",
    "utilizes our value operator, and (2) pass each batch of data through it\n",
    "before each epoch. The GAE module will update the input `tensordict`\n",
    "with new `\"advantage\"` and `\"value_target\"` entries. The\n",
    "`\"value_target\"` is a gradient-free tensor that represents the empirical\n",
    "value that the value network should represent with the input\n",
    "observation. Both of these will be used by\n",
    "`~torchrl.objectives.ClipPPOLoss`{.interpreted-text role=\"class\"} to\n",
    "return the policy and value losses.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "advantage_module = GAE(\n",
    "    gamma=gamma, lmbda=lmbda, value_network=value_module, average_gae=True\n",
    ")\n",
    "\n",
    "loss_module = ClipPPOLoss(\n",
    "    actor_network=policy_module,\n",
    "    critic_network=value_module,\n",
    "    clip_epsilon=clip_epsilon,\n",
    "    entropy_bonus=bool(entropy_eps),\n",
    "    entropy_coef=entropy_eps,\n",
    "    # these keys match by default but we set this for completeness\n",
    "    critic_coef=1.0,\n",
    "    loss_critic_type=\"smooth_l1\",\n",
    ")\n",
    "\n",
    "optim = torch.optim.Adam(loss_module.parameters(), lr)\n",
    "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(\n",
    "    optim, total_frames // frames_per_batch, 0.0\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training loop\n",
    "=============\n",
    "\n",
    "We now have all the pieces needed to code our training loop. The steps\n",
    "include:\n",
    "\n",
    "-   Collect data\n",
    "    -   Compute advantage\n",
    "        -   Loop over the collected to compute loss values\n",
    "        -   Back propagate\n",
    "        -   Optimize\n",
    "        -   Repeat\n",
    "    -   Repeat\n",
    "-   Repeat\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "eval cumulative reward:  344.0958 (init:  110.7517), eval step-count: 36, average reward= 9.3134 (init= 9.0834), step count (max): 116, lr policy:  0.0000: 100%|██████████| 50000/50000 [00:54<00:00, 912.68it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "eval cumulative reward:  344.0958 (init:  110.7517), eval step-count: 36, average reward= 9.3134 (init= 9.0834), step count (max): 116, lr policy:  0.0000: 100%|██████████| 50000/50000 [01:10<00:00, 912.68it/s]"
     ]
    }
   ],
   "source": [
    "logs = defaultdict(list)\n",
    "pbar = tqdm(total=total_frames)\n",
    "eval_str = \"\"\n",
    "\n",
    "# We iterate over the collector until it reaches the total number of frames it was\n",
    "# designed to collect:\n",
    "for i, tensordict_data in enumerate(collector):\n",
    "    # we now have a batch of data to work with. Let's learn something from it.\n",
    "    for _ in range(num_epochs):\n",
    "        # We'll need an \"advantage\" signal to make PPO work.\n",
    "        # We re-compute it at each epoch as its value depends on the value\n",
    "        # network which is updated in the inner loop.\n",
    "        advantage_module(tensordict_data)\n",
    "        data_view = tensordict_data.reshape(-1)\n",
    "        replay_buffer.extend(data_view.cpu())\n",
    "        for _ in range(frames_per_batch // sub_batch_size):\n",
    "            subdata = replay_buffer.sample(sub_batch_size)\n",
    "            loss_vals = loss_module(subdata.to(device))\n",
    "            loss_value = (\n",
    "                loss_vals[\"loss_objective\"]\n",
    "                + loss_vals[\"loss_critic\"]\n",
    "                + loss_vals[\"loss_entropy\"]\n",
    "            )\n",
    "\n",
    "            # Optimization: backward, grad clipping and optimization step\n",
    "            loss_value.backward()\n",
    "            # this is not strictly mandatory but it's good practice to keep\n",
    "            # your gradient norm bounded\n",
    "            torch.nn.utils.clip_grad_norm_(loss_module.parameters(), max_grad_norm)\n",
    "            optim.step()\n",
    "            optim.zero_grad()\n",
    "\n",
    "    logs[\"reward\"].append(tensordict_data[\"next\", \"reward\"].mean().item())\n",
    "    pbar.update(tensordict_data.numel())\n",
    "    cum_reward_str = (\n",
    "        f\"average reward={logs['reward'][-1]: 4.4f} (init={logs['reward'][0]: 4.4f})\"\n",
    "    )\n",
    "    logs[\"step_count\"].append(tensordict_data[\"step_count\"].max().item())\n",
    "    stepcount_str = f\"step count (max): {logs['step_count'][-1]}\"\n",
    "    logs[\"lr\"].append(optim.param_groups[0][\"lr\"])\n",
    "    lr_str = f\"lr policy: {logs['lr'][-1]: 4.4f}\"\n",
    "    if i % 10 == 0:\n",
    "        # We evaluate the policy once every 10 batches of data.\n",
    "        # Evaluation is rather simple: execute the policy without exploration\n",
    "        # (take the expected value of the action distribution) for a given\n",
    "        # number of steps (1000, which is our ``env`` horizon).\n",
    "        # The ``rollout`` method of the ``env`` can take a policy as argument:\n",
    "        # it will then execute this policy at each step.\n",
    "        with set_exploration_type(ExplorationType.MEAN), torch.no_grad():\n",
    "            # execute a rollout with the trained policy\n",
    "            eval_rollout = env.rollout(1000, policy_module)\n",
    "            logs[\"eval reward\"].append(eval_rollout[\"next\", \"reward\"].mean().item())\n",
    "            logs[\"eval reward (sum)\"].append(\n",
    "                eval_rollout[\"next\", \"reward\"].sum().item()\n",
    "            )\n",
    "            logs[\"eval step_count\"].append(eval_rollout[\"step_count\"].max().item())\n",
    "            eval_str = (\n",
    "                f\"eval cumulative reward: {logs['eval reward (sum)'][-1]: 4.4f} \"\n",
    "                f\"(init: {logs['eval reward (sum)'][0]: 4.4f}), \"\n",
    "                f\"eval step-count: {logs['eval step_count'][-1]}\"\n",
    "            )\n",
    "            del eval_rollout\n",
    "    pbar.set_description(\", \".join([eval_str, cum_reward_str, stepcount_str, lr_str]))\n",
    "\n",
    "    # We're also using a learning rate scheduler. Like the gradient clipping,\n",
    "    # this is a nice-to-have but nothing necessary for PPO to work.\n",
    "    scheduler.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Results\n",
    "=======\n",
    "\n",
    "Before the 1M step cap is reached, the algorithm should have reached a\n",
    "max step count of 1000 steps, which is the maximum number of steps\n",
    "before the trajectory is truncated.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 10))\n",
    "plt.subplot(2, 2, 1)\n",
    "plt.plot(logs[\"reward\"])\n",
    "plt.title(\"training rewards (average)\")\n",
    "plt.subplot(2, 2, 2)\n",
    "plt.plot(logs[\"step_count\"])\n",
    "plt.title(\"Max step count (training)\")\n",
    "plt.subplot(2, 2, 3)\n",
    "plt.plot(logs[\"eval reward (sum)\"])\n",
    "plt.title(\"Return (test)\")\n",
    "plt.subplot(2, 2, 4)\n",
    "plt.plot(logs[\"eval step_count\"])\n",
    "plt.title(\"Max step count (test)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conclusion and next steps\n",
    "=========================\n",
    "\n",
    "In this tutorial, we have learned:\n",
    "\n",
    "1.  How to create and customize an environment with\n",
    "    :py`torchrl`{.interpreted-text role=\"mod\"};\n",
    "2.  How to write a model and a loss function;\n",
    "3.  How to set up a typical training loop.\n",
    "\n",
    "If you want to experiment with this tutorial a bit more, you can apply\n",
    "the following modifications:\n",
    "\n",
    "-   From an efficiency perspective, we could run several simulations in\n",
    "    parallel to speed up data collection. Check\n",
    "    `~torchrl.envs.ParallelEnv`{.interpreted-text role=\"class\"} for\n",
    "    further information.\n",
    "-   From a logging perspective, one could add a\n",
    "    `torchrl.record.VideoRecorder`{.interpreted-text role=\"class\"}\n",
    "    transform to the environment after asking for rendering to get a\n",
    "    visual rendering of the inverted pendulum in action. Check\n",
    "    :py`torchrl.record`{.interpreted-text role=\"mod\"} to know more.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mac-rl",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
